package com.yt.system.controller;

import com.github.pagehelper.Page;
import com.yt.system.domain.*;
import com.yt.system.service.*;
import com.yt.system.utils.PageHelperUtil;
import com.yt.system.utils.PhotoUtil;
import com.yt.system.vo.OccupyResourceVO;
import com.yt.system.vo.UserApplyResourceVO;
import io.swagger.annotations.ApiImplicitParams;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Param;
import org.springframework.http.HttpRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.yt.system.dao.VacateMapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author 高铭
 * @date 2019/9/17 - 20:11
 */
@Api(value = "小组todo,资源申请，考勤三模块接口详列",tags = "小组todo,资源申请，考勤三模块接口详列")
@RequestMapping("/user")
@CrossOrigin(allowCredentials = "true")
@RestController
public class UserController {
    private static final int MAX_STR_LENGTH = 255;
    @Autowired
    private TaskService taskService;
    @Autowired
    UserService userService;
    @Autowired
    ClockService clockService;
    @Autowired
    VacateService vacateService;
    @Autowired
    ResourceService resourceService;
    /**
     * 添加任务     状态0：未提交，1：待审核，2：完成
     * @param task
     */
    @ApiOperation(value = "小组用户添加任务  状态0：未提交，1：待审核，2：完成")
    @RequestMapping(value = "/addTask",method = RequestMethod.POST)
    public Map<String,Object> addTask(@RequestBody Task task){
        Map<String,Object> map = new HashMap<>();
        //当用户添加任务时候，默认让任务状态为0：没通过(没提交)，任务不通过的理由是无
        task.setTstatus(0);
        //设置添加任务的开始时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        task.setTstarttime(sdf.format(new Date()));
        //设置审核不通过的理由为“无”
        task.setTreason("无");
        //定义一个最大字符串的长度
        if(task.getTcontent().length() > MAX_STR_LENGTH){
            map.put("code",0);
            map.put("msg","添加任务失败，内容的字段数超过255个字符");
            return map;
        }else{
            taskService.insert(task);
            map.put("code",1);
            map.put("msg","添加任务成功");
            return map;
        }
    }

    /**
     * 用户提交任务(提交次数可多次)，修改这个任务的状态
     * @param tid
     */
    @ApiOperation(value = "小组用户提交任务(提交次数可多次)，修改这个任务的状态")
    @RequestMapping(value = "/submitTask",method = RequestMethod.POST)
    public Map<String,Object> submitTask(@RequestParam("tid")Integer tid){
        Map<String,Object> map = new HashMap<>();
        //根据tid去找到相应的用户任务去修改任务的状态,将用户提交的这任务的状态设置为 1：待审核
        int tStatus = 1;
        taskService.updateTaskStatusByTid(tid,tStatus);
        map.put("code",0);
        map.put("msg","更改任务状态成功");
        return map;
    }

    /**
     * 组长审核组员任务状况--------------通过审核
     * @param tid
     * @return
     */
    @ApiOperation(value = "小组组长审核组员任务状况--------------通过审核")
    @RequestMapping(value = "/leaderToOk",method = RequestMethod.POST)
    public Map<String,Object> leaderToOk(Integer tid){
        Map<String,Object> map = new HashMap<>();
        //当组长审核通过组员的某个任务时候，将任务的状态修改为 2：审核通过(完成任务)
        int tStatus = 2;
        taskService.updateTaskStatusByTid(tid,tStatus);
        map.put("code",0);
        map.put("msg","更改任务状态成功");
        return map;
    }

    /**
     * 组长审核组员任务状况--------------不通过审核
     * @param tid
     * @param treason
     * @return
     */
    @ApiOperation(value = "小组组长审核组员任务状况--------------不通过审核")
    @RequestMapping(value = "/leaderToNo",method = RequestMethod.POST)
    public Map<String,Object> leaderToNo(Integer tid,String treason){
        System.out.println("===========tid:"+tid+"====不通过的原因===="+treason);
        Map<String,Object> map = new HashMap<>();
        //当组长审核不通过组员的某个任务时候，将任务的状态修改为 0：未通过，此时用户可以再次提交任务
        //而且要记录审核不通过的原因
        Task task = taskService.findTaskById(tid);
        if(treason.length() > MAX_STR_LENGTH){
            map.put("code",0);
            map.put("msg","修改任务失败，审核不通过的内容字段数超过255个字符");
            return map;
        }else{
            //将任务的状态修改为 0：未通过
            task.setTstatus(0);
            //记录审核不通过的原因
            task.setTreason(treason);
            //更新数据库
            taskService.updateTask(task);
            map.put("code",1);
            map.put("msg","修改任务成功");
            return map;
        }
    }

    /**
     * 查看当前登录用户的当天任务，以及这个用户所在组的其他组员的当天任务
     * @param aid
     * @return
     */
    @ApiOperation(value = "查看当前登录用户的当天任务，以及这个用户所在组的其他组员的当天任务")
    @RequestMapping(value = "/findTeamTask",method = RequestMethod.POST)
    public Map<String,Map<String,Object>> findTeamTask(Integer aid){
        Map<String,Map<String,Object>> bigMap = new HashMap<>();
        //定义一个时间格式，用来获取当前系统时间，去获取当天的任务，杜绝获取其他天的任务
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String tStartTime = sdf.format(new Date());
        //返回当前用户的当天的任务信息
        Map<String,Object> userTaskMap = taskService.findUserTaskByAid(aid,tStartTime);
        //返回当前用户所在组别的其余成员的当天任务所以信息
        Map<String,Object> teamOtherTaskMap = taskService.findTeamOtherTask(aid,tStartTime);
        bigMap.put("userTaskList",userTaskMap);
        bigMap.put("teamOtherTask",teamOtherTaskMap);
        return bigMap;
    }

    /**
     * 查询所有用户的信息
     * @return
     */
    @ApiOperation(value = "查询所有用户的信息")
    @GetMapping("/getAllUser")
    public List<User> getAllUser(){
        return userService.getAllUser();
    }

    /**
     * 根据用户ID查询用户信息
     * @param uid
     * @return
     */
    @ApiOperation(value = "根据用户ID查询用户信息")
    @GetMapping("/getUser/{uid}")
    public User getUser(@PathVariable("uid") Integer uid){
        return userService.selectByPrimaryKey(uid);
    }

    /**
     * 根据用户ID更新用户信息
     * @param user
     * @return
     */
    @ApiOperation(value = "根据用户ID更新用户信息; success表示更新成功，error表示更新失败")
    @PutMapping("/update")
    public String updateMessage(@RequestBody User user){
        System.out.println(user);
        int i = userService.updateByPrimaryKeySelective(user);
        if (i > 0){
            return "success";
        }else {
            return "error";
        }
    }

    /**
     * 传入用户id打卡签到
     * @param uid
     * @return
     */
    @ApiOperation("签到（传入用户id打卡签到）")
    @PostMapping("/clockIn")
    public Map<String,Object> clockIn(Integer uid){
        System.out.println("----------------------"+uid);
        Map<String,Object> map = new HashMap<>();
        if(uid != null) {
            int a = clockService.clockIn(uid);
            if (a > 0) {
                map.put("code", 1);
                map.put("msg", "打卡成功！");
                return map;
            }
            map.put("code", 0);
            map.put("msg", "打卡失败！");
            return map;
        }else {
            map.put("code", 0);
            map.put("msg", "查无用户！");
            return map;
        }
    }

    /**
     * 传入用户id签退
     * @param uid
     * @return
     * @throws ParseException
     */
    @ApiOperation("签退（传入用户id签退）")
    @PostMapping("/clockOut")
    public Map<String,Object> clockOut(Integer uid) throws ParseException {
        System.out.println("++++++++++++++++++"+uid);
        Map<String,Object> map = new HashMap<>();
        if(uid != null) {
            int a = clockService.clockOut(uid);
            if (a > 0) {
                map.put("code", 1);
                map.put("msg", "签退成功！");
                return map;
            }
            map.put("code", 0);
            map.put("msg", "签退失败！");
            return map;
        }else {
            map.put("code", 0);
            map.put("msg", "查无用户！");
            return map;
        }
    }

    /**
     * 查询用户所有打卡信息
     * @param uid
     * @return
     */
    @ApiOperation("查询签到信息（查询用户所有打卡信息）")
    @GetMapping("/findAllClockByUid")
    public List<Clock> findAllClockByUid(Integer uid){
        List<Clock> clocks = clockService.findAllClockByUid(uid);
        if (clocks.size() > 0){
            return clocks;
        }
        return null;
    }

    /**
     * 分页查询用户所有打卡信息
     * @param uid
     * @return
     */
    @ApiOperation("分页查询签到信息（查询用户所有打卡信息）")
    @GetMapping("/findPageByUid")
    public PageVO<Object> findPageByUid(Integer uid, PageQO pageQO){
        PageHelperUtil pageHelperUtil = new PageHelperUtil();
        Page<Object> objectPage = pageHelperUtil.PageTest(pageQO);
        clockService.findAllClockByUid(uid);
        PageVO<Object> pageVO = PageVO.build(objectPage);
        return pageVO;
    }

    /**
     * 传入uid、请假时间段、请假原因添加申请请假
     * @param uid, vcontent, vstart, end, file
     * @return
     */
    @ApiOperation("请假（传入uid、请假时间段、请假原因添加申请请假）")
    @PostMapping("/insertLeave")
    public Map<String,Object> insertLeave(Integer uid, String vcontent, String vstart, String vend, MultipartFile file){
        Vacate vacate = new Vacate(uid, vcontent, vstart, vend);
        if (file != null){
            String fileName = PhotoUtil.putPic(file);
            vacate.setVphoto(fileName);
        }
        Map<String,Object> map = new HashMap<>();
        int a = vacateService.insertLeave(vacate);
        if (vacate != null) {
            if (a > 0) {
                map.put("code", 1);
                map.put("msg", "提交申请成功！");
                return map;
            }
        }
        map.put("code",0);
        map.put("msg","提交申请失败！");
        return map;
    }

    /**
     * 传入uid、续假时间段、续假原因添加申请续假
     * @param uid, vcontent, vstart, end, file
     * @return
     */
    @ApiOperation("续假（传入uid、续假时间段、续假原因添加申请续假）")
    @PostMapping("/insertExtend")
    public Map<String,Object> insertExtend(Integer uid, String vcontent, String vstart, String vend, MultipartFile file){
        Vacate vacate = new Vacate(uid, vcontent, vstart, vend);
        if (file != null){
            String fileName = PhotoUtil.putPic(file);
            vacate.setVphoto(fileName);
        }
        Map<String,Object> map = new HashMap<>();
        int a = vacateService.insertExtend(vacate);
        if (a > 0){
            map.put("code",1);
            map.put("msg","提交申请成功！");
            return map;
        }
        map.put("code",0);
        map.put("msg","提交申请失败！");
        return map;
    }

    /**
     * 传入vid和销假时间进行销假
     * @param vacate
     * @return
     */
    @ApiOperation("销假（传入vid和销假时间进行销假）")
    @PostMapping("/sellingOffLeave")
    public Map<String,Object> sellingOffLeave(Vacate vacate){
        Map<String,Object> map = new HashMap<>();
        int a = vacateService.sellingOffLeave(vacate);
        if (a > 0){
            map.put("code",1);
            map.put("msg","销假成功！");
            return map;
        }
        map.put("code",0);
        map.put("msg","销假失败！");
        return map;
    }

    /**
     * 传入uid、vstatus、vflag查询请假信息
     * @param vacate
     * @return
     */
    @ApiOperation("查找请假信息（传入uid、vstatus、vflag查询请假信息）")
    @PostMapping("/findAllVacate")
    public List<Vacate> findAllVacate(Vacate vacate){
        List<Vacate> vacates = vacateService.findAllVacate(vacate);
        if(vacates.size() > 0){
            return vacates;
        }
        return null;
    }

    /**
     * 查找资源占用信息
     * @param rid
     * @return
     */
    @ApiOperation("查找资源占用信息（传入rid查询资源占用信息）")
    @GetMapping("/findOccupyResources")
    public List<OccupyResourceVO> findOccupyResources(Integer rid){
        List<OccupyResourceVO> list = null;
        list = resourceService.selectByRid(rid);
        return list;
    }

    /**
     * 用户申请资源
     * @param applyresource
     * @return
     */
    @ApiOperation("申请资源（传入aruid(用户ID)、arrid(资源ID)、" +
            "arstarttime(申请的开始时间)、arendtime(申请的结束时间)查询资源占用信息）")
    @PostMapping("/applyResource")
    public Map<String,Object> applyResource (@RequestBody Applyresource applyresource){
        Boolean isSuccess = false;
        Map<String,Object> map = new HashMap<>();
        isSuccess = resourceService.applyResource(applyresource);
        if(isSuccess){
            map.put("code",1);
            map.put("msg","申请成功！");
            return map;
        }else {
            map.put("code",0);
            map.put("msg","该资源不可申请！");
            return map;
        }
    }

    /**
     * 查看本用户相关的资源
     * @param uid
     * @return
     */
    @ApiOperation("查看本用户相关的资源（传入uid查询资源占用信息[0申请的/1通过申请的/2提交归还的/3已归还的/4超时的]）")
    @GetMapping("/findMyResources")
    public List<UserApplyResourceVO> findMyResources(Integer uid){
        List<UserApplyResourceVO> list = null;
        list = resourceService.selectByUid(uid);
        return list;
    }

    /**
     * 归还资源（状态为1通过申请的数据才可以归还）
     * @param arid
     * @return
     */
    @ApiOperation("归还资源（传入arid进行资源归还，状态为1通过申请的数据才可以归还)" )
    @GetMapping("/returnResource")
    public Map<String,Object> returnResource (Integer arid){
        Boolean isSuccess = false;
        Map<String,Object> map = new HashMap<>();
        isSuccess = resourceService.returnResource(arid);
        if(isSuccess){
            map.put("code",1);
            map.put("msg","归还成功！");
            return map;
        }else {
            map.put("code",0);
            map.put("msg","该资源不可归还！");
            return map;
        }
    }

    @ApiOperation("审核资源申请（传入arid进行资源归还，状态为0才可以进行审核)" )
    @GetMapping("/checkResource")
    public Map<String,Object> checkResource (Integer arid){
        Boolean isSuccess = false;
        Map<String,Object> map = new HashMap<>();
        isSuccess = resourceService.checkResource(arid);
        if(isSuccess){
            map.put("code",1);
            map.put("msg","审核通过！");
            return map;
        }else {
            map.put("code",0);
            map.put("msg","审核不通过！");
            return map;
        }
    }

    /**
     * 取消申请（状态为0申请的数据才可以取消 先不实现：通知管理员 ）
     * @param arid
     * @return
     */
    @ApiOperation("取消申请（传入arid进行取消申请，状态为0申请的数据才可以取消)" )
    @DeleteMapping("/cancelApply")
    public Map<String,Object> cancelApply (Integer arid){
        Boolean isSuccess = false;
        Map<String,Object> map = new HashMap<>();
        isSuccess = resourceService.cancelApply(arid);
        if(isSuccess){
            map.put("code",1);
            map.put("msg","取消成功！");
            return map;
        }else {
            map.put("code",0);
            map.put("msg","该记录不可以取消！");
            return map;
        }
    }

    /**
     * 查看所有资源类型
     * @param uid
     * @return
     */
    @ApiOperation("查看所有资源类型")
    @GetMapping("/selectResourceType")
    public List<Integer> selectResourceType(Integer uid){
        List<Integer> list = null;
        list = resourceService.selectResourceType();
        return list;
    }

    @ApiOperation("查询所有资源")
    @RequestMapping(value = "findAllResouce",method = RequestMethod.POST)
    public List<Resource> findAllResouce(){
        List<Resource> list = resourceService.findAllResource();
        return list;
    }

    @ApiOperation("插入用户信息")
    @PostMapping("/insertSelective")
    public String insertSelective(@RequestBody User user){
        try{
            userService.insertSelective(user);
            return "success";
        }catch (Exception e){
            e.printStackTrace();
            return "error";
        }
    }

    @ApiOperation("修改头像")
    @PostMapping("/saveImg")
    public String saveImg(MultipartFile file, Integer uid){
        if (file != null){
            String img = PhotoUtil.putPhoto(file,uid);
            userService.saveImg(uid,img);
            return "success";
        }else {
            return "error";
        }

    }

}
